package common.util;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.BinaryJedisPubSub;
import redis.clients.jedis.BitOP;
import redis.clients.jedis.BitPosParams;
import redis.clients.jedis.Client;
import redis.clients.jedis.DebugParams;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster.Reset;
import redis.clients.jedis.JedisMonitor;
import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams;
import redis.clients.jedis.params.geo.GeoRadiusParam;
import redis.clients.jedis.params.sortedset.ZAddParams;
import redis.clients.jedis.params.sortedset.ZIncrByParams;
import redis.clients.util.Pool;
import redis.clients.util.Slowlog;

public class RedisUtil {
    private RedisUtil() {}

    public static void set(Map<String, Object> cMap) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Entry<String, Object>> tEntrySet = cMap.entrySet();
        tEntrySet.forEach(tEntry -> tJedis.set(tEntry.getKey(), tEntry.getValue().toString()));
        tJedis.close();
    }

    public static String set(String cKey, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue);
        tJedis.close();
        return tSet;
    }

    public static String set(String cKey, String cValue, String cNxxx, String cExpx, long cTime) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx, cExpx, cTime);
        tJedis.close();
        return tSet;
    }

    public static String get(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tGet = tJedis.get(cKey);
        tJedis.close();
        return tGet;
    }

    public static Long exists(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExists = tJedis.exists(cKeys);
        tJedis.close();
        return tExists;
    }

    public static Boolean exists(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tExists = tJedis.exists(cKey);
        tJedis.close();
        return tExists;
    }

    public static Long del(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDel = tJedis.del(cKeys);
        tJedis.close();
        return tDel;
    }

    public static Long del(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDel = tJedis.del(cKey);
        tJedis.close();
        return tDel;
    }

    public static String type(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tType = tJedis.type(cKey);
        tJedis.close();
        return tType;
    }

    public static Set<String> keys(String cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tKeys = tJedis.keys(cPattern);
        tJedis.close();
        return tKeys;
    }

    public static String randomKey() {
        Jedis tJedis = RedisPool.getJedis();
        String tRandomKey = tJedis.randomKey();
        tJedis.close();
        return tRandomKey;
    }

    public static String rename(String cOldkey, String cNewkey) {
        Jedis tJedis = RedisPool.getJedis();
        String tRename = tJedis.rename(cOldkey, cNewkey);
        tJedis.close();
        return tRename;
    }

    public static Long renamenx(String cOldkey, String cNewkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRenamenx = tJedis.renamenx(cOldkey, cNewkey);
        tJedis.close();
        return tRenamenx;
    }

    public static Long expire(String cKey, int cSeconds) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExpire = tJedis.expire(cKey, cSeconds);
        tJedis.close();
        return tExpire;
    }

    public static Long expireAt(String cKey, long cUnixTime) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExpireAt = tJedis.expireAt(cKey, cUnixTime);
        tJedis.close();
        return tExpireAt;
    }

    public static Long ttl(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tTtl = tJedis.ttl(cKey);
        tJedis.close();
        return tTtl;
    }

    public static Long move(String cKey, int cDbIndex) {
        Jedis tJedis = RedisPool.getJedis();
        Long tMove = tJedis.move(cKey, cDbIndex);
        tJedis.close();
        return tMove;
    }

    public static String getSet(String cKey, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tGetSet = tJedis.getSet(cKey, cValue);
        tJedis.close();
        return tGetSet;
    }

    public static List<String> mget(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tMget = tJedis.mget(cKeys);
        tJedis.close();
        return tMget;
    }

    public static Long setnx(String cKey, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSetnx = tJedis.setnx(cKey, cValue);
        tJedis.close();
        return tSetnx;
    }

    public static String setex(String cKey, int cSeconds, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tSetex = tJedis.setex(cKey, cSeconds, cValue);
        tJedis.close();
        return tSetex;
    }

    public static String mset(String... cKeysvalues) {
        Jedis tJedis = RedisPool.getJedis();
        String tMset = tJedis.mset(cKeysvalues);
        tJedis.close();
        return tMset;
    }

    public static Long msetnx(String... cKeysvalues) {
        Jedis tJedis = RedisPool.getJedis();
        Long tMsetnx = tJedis.msetnx(cKeysvalues);
        tJedis.close();
        return tMsetnx;
    }

    public static Long decrBy(String cKey, long cInteger) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDecrBy = tJedis.decrBy(cKey, cInteger);
        tJedis.close();
        return tDecrBy;
    }

    public static Long decr(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDecr = tJedis.decr(cKey);
        tJedis.close();
        return tDecr;
    }

    public static Long incrBy(String cKey, long cInteger) {
        Jedis tJedis = RedisPool.getJedis();
        Long tIncrBy = tJedis.incrBy(cKey, cInteger);
        tJedis.close();
        return tIncrBy;
    }

    public static Double incrByFloat(String cKey, double cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Double tIncrByFloat = tJedis.incrByFloat(cKey, cValue);
        tJedis.close();
        return tIncrByFloat;
    }

    public static Long incr(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tIncr = tJedis.incr(cKey);
        tJedis.close();
        return tIncr;
    }

    public static Long append(String cKey, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tAppend = tJedis.append(cKey, cValue);
        tJedis.close();
        return tAppend;
    }

    public static String substr(String cKey, int cStart, int cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        String tSubstr = tJedis.substr(cKey, cStart, cEnd);
        tJedis.close();
        return tSubstr;
    }

    public static Long hset(String cKey, String cField, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHset = tJedis.hset(cKey, cField, cValue);
        tJedis.close();
        return tHset;
    }

    public static String hget(String cKey, String cField) {
        Jedis tJedis = RedisPool.getJedis();
        String tHget = tJedis.hget(cKey, cField);
        tJedis.close();
        return tHget;
    }

    public static Long hsetnx(String cKey, String cField, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHsetnx = tJedis.hsetnx(cKey, cField, cValue);
        tJedis.close();
        return tHsetnx;
    }

    public static String hmset(String cKey, Map<String, String> cHash) {
        Jedis tJedis = RedisPool.getJedis();
        String tHmset = tJedis.hmset(cKey, cHash);
        tJedis.close();
        return tHmset;
    }

    public static List<String> hmget(String cKey, String... cFields) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tHmget = tJedis.hmget(cKey, cFields);
        tJedis.close();
        return tHmget;
    }

    public static Long hincrBy(String cKey, String cField, long cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHincrBy = tJedis.hincrBy(cKey, cField, cValue);
        tJedis.close();
        return tHincrBy;
    }

    public static Double hincrByFloat(String cKey, String cField, double cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Double tHincrByFloat = tJedis.hincrByFloat(cKey, cField, cValue);
        tJedis.close();
        return tHincrByFloat;
    }

    public static Boolean hexists(String cKey, String cField) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tHexists = tJedis.hexists(cKey, cField);
        tJedis.close();
        return tHexists;
    }

    public static Long hdel(String cKey, String... cFields) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHdel = tJedis.hdel(cKey, cFields);
        tJedis.close();
        return tHdel;
    }

    public static Long hlen(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHlen = tJedis.hlen(cKey);
        tJedis.close();
        return tHlen;
    }

    public static Set<String> hkeys(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tHkeys = tJedis.hkeys(cKey);
        tJedis.close();
        return tHkeys;
    }

    public static List<String> hvals(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tHvals = tJedis.hvals(cKey);
        tJedis.close();
        return tHvals;
    }

    public static Map<String, String> hgetAll(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Map<String, String> tHgetAll = tJedis.hgetAll(cKey);
        tJedis.close();
        return tHgetAll;
    }

    public static Long rpush(String cKey, String... cStrings) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRpush = tJedis.rpush(cKey, cStrings);
        tJedis.close();
        return tRpush;
    }

    public static Long lpush(String cKey, String... cStrings) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLpush = tJedis.lpush(cKey, cStrings);
        tJedis.close();
        return tLpush;
    }

    public static Long llen(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLlen = tJedis.llen(cKey);
        tJedis.close();
        return tLlen;
    }

    public static List<String> lrange(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tLrange = tJedis.lrange(cKey, cStart, cEnd);
        tJedis.close();
        return tLrange;
    }

    public static String ltrim(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        String tLtrim = tJedis.ltrim(cKey, cStart, cEnd);
        tJedis.close();
        return tLtrim;
    }

    public static String lindex(String cKey, long cIndex) {
        Jedis tJedis = RedisPool.getJedis();
        String tLindex = tJedis.lindex(cKey, cIndex);
        tJedis.close();
        return tLindex;
    }

    public static String lset(String cKey, long cIndex, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tLset = tJedis.lset(cKey, cIndex, cValue);
        tJedis.close();
        return tLset;
    }

    public static Long lrem(String cKey, long cCount, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLrem = tJedis.lrem(cKey, cCount, cValue);
        tJedis.close();
        return tLrem;
    }

    public static String lpop(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tLpop = tJedis.lpop(cKey);
        tJedis.close();
        return tLpop;
    }

    public static String rpop(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tRpop = tJedis.rpop(cKey);
        tJedis.close();
        return tRpop;
    }

    public static String rpoplpush(String cSrckey, String cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        String tRpoplpush = tJedis.rpoplpush(cSrckey, cDstkey);
        tJedis.close();
        return tRpoplpush;
    }

    public static Long sadd(String cKey, String... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSadd = tJedis.sadd(cKey, cMembers);
        tJedis.close();
        return tSadd;
    }

    public static Set<String> smembers(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tSmembers = tJedis.smembers(cKey);
        tJedis.close();
        return tSmembers;
    }

    public static Long srem(String cKey, String... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSrem = tJedis.srem(cKey, cMembers);
        tJedis.close();
        return tSrem;
    }

    public static String spop(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tSpop = tJedis.spop(cKey);
        tJedis.close();
        return tSpop;
    }

    public static Set<String> spop(String cKey, long cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tSpop = tJedis.spop(cKey, cCount);
        tJedis.close();
        return tSpop;
    }

    public static Long smove(String cSrckey, String cDstkey, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSmove = tJedis.smove(cSrckey, cDstkey, cMember);
        tJedis.close();
        return tSmove;
    }

    public static Long scard(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tScard = tJedis.scard(cKey);
        tJedis.close();
        return tScard;
    }

    public static Boolean sismember(String cKey, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSismember = tJedis.sismember(cKey, cMember);
        tJedis.close();
        return tSismember;
    }

    public static Set<String> sinter(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tSinter = tJedis.sinter(cKeys);
        tJedis.close();
        return tSinter;
    }

    public static Long sinterstore(String cDstkey, String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSinterstore = tJedis.sinterstore(cDstkey, cKeys);
        tJedis.close();
        return tSinterstore;
    }

    public static Set<String> sunion(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tSunion = tJedis.sunion(cKeys);
        tJedis.close();
        return tSunion;
    }

    public static Long sunionstore(String cDstkey, String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSunionstore = tJedis.sunionstore(cDstkey, cKeys);
        tJedis.close();
        return tSunionstore;
    }

    public static Set<String> sdiff(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tSdiff = tJedis.sdiff(cKeys);
        tJedis.close();
        return tSdiff;
    }

    public static Long sdiffstore(String cDstkey, String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSdiffstore = tJedis.sdiffstore(cDstkey, cKeys);
        tJedis.close();
        return tSdiffstore;
    }

    public static String srandmember(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tSrandmember = tJedis.srandmember(cKey);
        tJedis.close();
        return tSrandmember;
    }

    public static List<String> srandmember(String cKey, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tSrandmember = tJedis.srandmember(cKey, cCount);
        tJedis.close();
        return tSrandmember;
    }

    public static Long zadd(String cKey, double cScore, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScore, cMember);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(String cKey, double cScore, String cMember, ZAddParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScore, cMember, cParams);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(String cKey, Map<String, Double> cScoreMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScoreMembers);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(String cKey, Map<String, Double> cScoreMembers, ZAddParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScoreMembers, cParams);
        tJedis.close();
        return tZadd;
    }

    public static Set<String> zrange(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrange = tJedis.zrange(cKey, cStart, cEnd);
        tJedis.close();
        return tZrange;
    }

    public static Long zrem(String cKey, String... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrem = tJedis.zrem(cKey, cMembers);
        tJedis.close();
        return tZrem;
    }

    public static Double zincrby(String cKey, double cScore, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZincrby = tJedis.zincrby(cKey, cScore, cMember);
        tJedis.close();
        return tZincrby;
    }

    public static Double zincrby(String cKey, double cScore, String cMember, ZIncrByParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZincrby = tJedis.zincrby(cKey, cScore, cMember, cParams);
        tJedis.close();
        return tZincrby;
    }

    public static Long zrank(String cKey, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrank = tJedis.zrank(cKey, cMember);
        tJedis.close();
        return tZrank;
    }

    public static Long zrevrank(String cKey, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrevrank = tJedis.zrevrank(cKey, cMember);
        tJedis.close();
        return tZrevrank;
    }

    public static Set<String> zrevrange(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrange = tJedis.zrevrange(cKey, cStart, cEnd);
        tJedis.close();
        return tZrevrange;
    }

    public static Set<Tuple> zrangeWithScores(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeWithScores = tJedis.zrangeWithScores(cKey, cStart, cEnd);
        tJedis.close();
        return tZrangeWithScores;
    }

    public static Set<Tuple> zrevrangeWithScores(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeWithScores = tJedis.zrevrangeWithScores(cKey, cStart, cEnd);
        tJedis.close();
        return tZrevrangeWithScores;
    }

    public static Long zcard(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcard = tJedis.zcard(cKey);
        tJedis.close();
        return tZcard;
    }

    public static Double zscore(String cKey, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZscore = tJedis.zscore(cKey, cMember);
        tJedis.close();
        return tZscore;
    }

    public static String watch(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        String tWatch = tJedis.watch(cKeys);
        tJedis.close();
        return tWatch;
    }

    public static List<String> sort(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tSort = tJedis.sort(cKey);
        tJedis.close();
        return tSort;
    }

    public static List<String> sort(String cKey, SortingParams cSortingParameters) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tSort = tJedis.sort(cKey, cSortingParameters);
        tJedis.close();
        return tSort;
    }

    public static List<String> blpop(int cTimeout, String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBlpop = tJedis.blpop(cTimeout, cKeys);
        tJedis.close();
        return tBlpop;
    }

    public static List<String> blpop(String... cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBlpop = tJedis.blpop(cArgs);
        tJedis.close();
        return tBlpop;
    }

    public static List<String> brpop(String... cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBrpop = tJedis.brpop(cArgs);
        tJedis.close();
        return tBrpop;
    }

    public static Long sort(String cKey, SortingParams cSortingParameters, String cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSort = tJedis.sort(cKey, cSortingParameters, cDstkey);
        tJedis.close();
        return tSort;
    }

    public static Long sort(String cKey, String cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSort = tJedis.sort(cKey, cDstkey);
        tJedis.close();
        return tSort;
    }

    public static List<String> brpop(int cTimeout, String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBrpop = tJedis.brpop(cTimeout, cKeys);
        tJedis.close();
        return tBrpop;
    }

    public static Long zcount(String cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcount = tJedis.zcount(cKey, cMin, cMax);
        tJedis.close();
        return tZcount;
    }

    public static Long zcount(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcount = tJedis.zcount(cKey, cMin, cMax);
        tJedis.close();
        return tZcount;
    }

    public static Set<String> zrangeByScore(String cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<String> zrangeByScore(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<String> zrangeByScore(String cKey, double cMin, double cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<String> zrangeByScore(String cKey, String cMin, String cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<Tuple> zrangeByScoreWithScores(String cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(String cKey, double cMin, double cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(String cKey, String cMin, String cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<String> zrevrangeByScore(String cKey, double cMax, double cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<String> zrevrangeByScore(String cKey, String cMax, String cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<String> zrevrangeByScore(String cKey, double cMax, double cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(String cKey, double cMax, double cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(String cKey, double cMax, double cMin, int cOffset,
            int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(String cKey, String cMax, String cMin, int cOffset,
            int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<String> zrevrangeByScore(String cKey, String cMax, String cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(String cKey, String cMax, String cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Long zremrangeByRank(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByRank = tJedis.zremrangeByRank(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByRank;
    }

    public static Long zremrangeByScore(String cKey, double cStart, double cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByScore = tJedis.zremrangeByScore(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByScore;
    }

    public static Long zremrangeByScore(String cKey, String cStart, String cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByScore = tJedis.zremrangeByScore(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByScore;
    }

    public static Long zunionstore(String cDstkey, String... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZunionstore = tJedis.zunionstore(cDstkey, cSets);
        tJedis.close();
        return tZunionstore;
    }

    public static Long zunionstore(String cDstkey, ZParams cParams, String... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZunionstore = tJedis.zunionstore(cDstkey, cParams, cSets);
        tJedis.close();
        return tZunionstore;
    }

    public static Long zinterstore(String cDstkey, String... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZinterstore = tJedis.zinterstore(cDstkey, cSets);
        tJedis.close();
        return tZinterstore;
    }

    public static Long zinterstore(String cDstkey, ZParams cParams, String... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZinterstore = tJedis.zinterstore(cDstkey, cParams, cSets);
        tJedis.close();
        return tZinterstore;
    }

    public static Long zlexcount(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZlexcount = tJedis.zlexcount(cKey, cMin, cMax);
        tJedis.close();
        return tZlexcount;
    }

    public static Set<String> zrangeByLex(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByLex = tJedis.zrangeByLex(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByLex;
    }

    public static Set<String> zrangeByLex(String cKey, String cMin, String cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrangeByLex = tJedis.zrangeByLex(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByLex;
    }

    public static Set<String> zrevrangeByLex(String cKey, String cMax, String cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByLex = tJedis.zrevrangeByLex(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByLex;
    }

    public static Set<String> zrevrangeByLex(String cKey, String cMax, String cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<String> tZrevrangeByLex = tJedis.zrevrangeByLex(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByLex;
    }

    public static Long zremrangeByLex(String cKey, String cMin, String cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByLex = tJedis.zremrangeByLex(cKey, cMin, cMax);
        tJedis.close();
        return tZremrangeByLex;
    }

    public static Long strlen(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tStrlen = tJedis.strlen(cKey);
        tJedis.close();
        return tStrlen;
    }

    public static Long lpushx(String cKey, String... cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLpushx = tJedis.lpushx(cKey, cString);
        tJedis.close();
        return tLpushx;
    }

    public static Long persist(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPersist = tJedis.persist(cKey);
        tJedis.close();
        return tPersist;
    }

    public static Long rpushx(String cKey, String... cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRpushx = tJedis.rpushx(cKey, cString);
        tJedis.close();
        return tRpushx;
    }

    public static String echo(String cString) {
        Jedis tJedis = RedisPool.getJedis();
        String tEcho = tJedis.echo(cString);
        tJedis.close();
        return tEcho;
    }

    public static Long linsert(String cKey, LIST_POSITION cWhere, String cPivot, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLinsert = tJedis.linsert(cKey, cWhere, cPivot, cValue);
        tJedis.close();
        return tLinsert;
    }

    public static String brpoplpush(String cSource, String cDestination, int cTimeout) {
        Jedis tJedis = RedisPool.getJedis();
        String tBrpoplpush = tJedis.brpoplpush(cSource, cDestination, cTimeout);
        tJedis.close();
        return tBrpoplpush;
    }

    public static Boolean setbit(String cKey, long cOffset, boolean cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSetbit = tJedis.setbit(cKey, cOffset, cValue);
        tJedis.close();
        return tSetbit;
    }

    public static Boolean setbit(String cKey, long cOffset, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSetbit = tJedis.setbit(cKey, cOffset, cValue);
        tJedis.close();
        return tSetbit;
    }

    public static Boolean getbit(String cKey, long cOffset) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tGetbit = tJedis.getbit(cKey, cOffset);
        tJedis.close();
        return tGetbit;
    }

    public static Long setrange(String cKey, long cOffset, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSetrange = tJedis.setrange(cKey, cOffset, cValue);
        tJedis.close();
        return tSetrange;
    }

    public static String getrange(String cKey, long cStartOffset, long cEndOffset) {
        Jedis tJedis = RedisPool.getJedis();
        String tGetrange = tJedis.getrange(cKey, cStartOffset, cEndOffset);
        tJedis.close();
        return tGetrange;
    }

    public static Long bitpos(String cKey, boolean cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitpos = tJedis.bitpos(cKey, cValue);
        tJedis.close();
        return tBitpos;
    }

    public static Long bitpos(String cKey, boolean cValue, BitPosParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitpos = tJedis.bitpos(cKey, cValue, cParams);
        tJedis.close();
        return tBitpos;
    }

    public static List<String> configGet(String cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tConfigGet = tJedis.configGet(cPattern);
        tJedis.close();
        return tConfigGet;
    }

    public static String configSet(String cParameter, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tConfigSet = tJedis.configSet(cParameter, cValue);
        tJedis.close();
        return tConfigSet;
    }

    public static Object eval(String cScript, int cKeyCount, String... cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript, cKeyCount, cParams);
        tJedis.close();
        return tEval;
    }

    public static void subscribe(JedisPubSub cJedisPubSub, String... cChannels) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.subscribe(cJedisPubSub, cChannels);
    }

    public static Long publish(String cChannel, String cMessage) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPublish = tJedis.publish(cChannel, cMessage);
        tJedis.close();
        return tPublish;
    }

    public static void psubscribe(JedisPubSub cJedisPubSub, String... cPatterns) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.psubscribe(cJedisPubSub, cPatterns);
    }

    public static Object eval(String cScript, List<String> cKeys, List<String> cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript, cKeys, cArgs);
        tJedis.close();
        return tEval;
    }

    public static Object eval(String cScript) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript);
        tJedis.close();
        return tEval;
    }

    public static Object evalsha(String cScript) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cScript);
        tJedis.close();
        return tEvalsha;
    }

    public static Object evalsha(String cSha1, List<String> cKeys, List<String> cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cSha1, cKeys, cArgs);
        tJedis.close();
        return tEvalsha;
    }

    public static Object evalsha(String cSha1, int cKeyCount, String... cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cSha1, cKeyCount, cParams);
        tJedis.close();
        return tEvalsha;
    }

    public static Boolean scriptExists(String cSha1) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tScriptExists = tJedis.scriptExists(cSha1);
        tJedis.close();
        return tScriptExists;
    }

    public static List<Boolean> scriptExists(String... cSha1) {
        Jedis tJedis = RedisPool.getJedis();
        List<Boolean> tScriptExists = tJedis.scriptExists(cSha1);
        tJedis.close();
        return tScriptExists;
    }

    public static String scriptLoad(String cScript) {
        Jedis tJedis = RedisPool.getJedis();
        String tScriptLoad = tJedis.scriptLoad(cScript);
        tJedis.close();
        return tScriptLoad;
    }

    public static List<Slowlog> slowlogGet() {
        Jedis tJedis = RedisPool.getJedis();
        List<Slowlog> tSlowlogGet = tJedis.slowlogGet();
        tJedis.close();
        return tSlowlogGet;
    }

    public static List<Slowlog> slowlogGet(long cEntries) {
        Jedis tJedis = RedisPool.getJedis();
        List<Slowlog> tSlowlogGet = tJedis.slowlogGet(cEntries);
        tJedis.close();
        return tSlowlogGet;
    }

    public static Long objectRefcount(String cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tObjectRefcount = tJedis.objectRefcount(cString);
        tJedis.close();
        return tObjectRefcount;
    }

    public static String objectEncoding(String cString) {
        Jedis tJedis = RedisPool.getJedis();
        String tObjectEncoding = tJedis.objectEncoding(cString);
        tJedis.close();
        return tObjectEncoding;
    }

    public static Long objectIdletime(String cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tObjectIdletime = tJedis.objectIdletime(cString);
        tJedis.close();
        return tObjectIdletime;
    }

    public static Long bitcount(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitcount = tJedis.bitcount(cKey);
        tJedis.close();
        return tBitcount;
    }

    public static Long bitcount(String cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitcount = tJedis.bitcount(cKey, cStart, cEnd);
        tJedis.close();
        return tBitcount;
    }

    public static Long bitop(BitOP cOp, String cDestKey, String... cSrcKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitop = tJedis.bitop(cOp, cDestKey, cSrcKeys);
        tJedis.close();
        return tBitop;
    }

    public static List<Map<String, String>> sentinelMasters() {
        Jedis tJedis = RedisPool.getJedis();
        List<Map<String, String>> tSentinelMasters = tJedis.sentinelMasters();
        tJedis.close();
        return tSentinelMasters;
    }

    public static List<String> sentinelGetMasterAddrByName(String cMasterName) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tSentinelGetMasterAddrByName = tJedis.sentinelGetMasterAddrByName(cMasterName);
        tJedis.close();
        return tSentinelGetMasterAddrByName;
    }

    public static Long sentinelReset(String cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSentinelReset = tJedis.sentinelReset(cPattern);
        tJedis.close();
        return tSentinelReset;
    }

    public static List<Map<String, String>> sentinelSlaves(String cMasterName) {
        Jedis tJedis = RedisPool.getJedis();
        List<Map<String, String>> tSentinelSlaves = tJedis.sentinelSlaves(cMasterName);
        tJedis.close();
        return tSentinelSlaves;
    }

    public static String sentinelFailover(String cMasterName) {
        Jedis tJedis = RedisPool.getJedis();
        String tSentinelFailover = tJedis.sentinelFailover(cMasterName);
        tJedis.close();
        return tSentinelFailover;
    }

    public static String sentinelMonitor(String cMasterName, String cIp, int cPort, int cQuorum) {
        Jedis tJedis = RedisPool.getJedis();
        String tSentinelMonitor = tJedis.sentinelMonitor(cMasterName, cIp, cPort, cQuorum);
        tJedis.close();
        return tSentinelMonitor;
    }

    public static String sentinelRemove(String cMasterName) {
        Jedis tJedis = RedisPool.getJedis();
        String tSentinelRemove = tJedis.sentinelRemove(cMasterName);
        tJedis.close();
        return tSentinelRemove;
    }

    public static String sentinelSet(String cMasterName, Map<String, String> cParameterMap) {
        Jedis tJedis = RedisPool.getJedis();
        String tSentinelSet = tJedis.sentinelSet(cMasterName, cParameterMap);
        tJedis.close();
        return tSentinelSet;
    }

    public static byte[] dump(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tDump = tJedis.dump(cKey);
        tJedis.close();
        return tDump;
    }

    public static String restore(String cKey, int cTtl, byte[] cSerializedValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tRestore = tJedis.restore(cKey, cTtl, cSerializedValue);
        tJedis.close();
        return tRestore;
    }

    public static Long pexpire(String cKey, long cMilliseconds) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPexpire = tJedis.pexpire(cKey, cMilliseconds);
        tJedis.close();
        return tPexpire;
    }

    public static Long pexpireAt(String cKey, long cMillisecondsTimestamp) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPexpireAt = tJedis.pexpireAt(cKey, cMillisecondsTimestamp);
        tJedis.close();
        return tPexpireAt;
    }

    public static Long pttl(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPttl = tJedis.pttl(cKey);
        tJedis.close();
        return tPttl;
    }

    public static String psetex(String cKey, long cMilliseconds, String cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tPsetex = tJedis.psetex(cKey, cMilliseconds, cValue);
        tJedis.close();
        return tPsetex;
    }

    public static String set(String cKey, String cValue, String cNxxx) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx);
        tJedis.close();
        return tSet;
    }

    public static String set(String cKey, String cValue, String cNxxx, String cExpx, int cTime) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx, cExpx, cTime);
        tJedis.close();
        return tSet;
    }

    public static String clientKill(String cClient) {
        Jedis tJedis = RedisPool.getJedis();
        String tClientKill = tJedis.clientKill(cClient);
        tJedis.close();
        return tClientKill;
    }

    public static String clientSetname(String cName) {
        Jedis tJedis = RedisPool.getJedis();
        String tClientSetname = tJedis.clientSetname(cName);
        tJedis.close();
        return tClientSetname;
    }

    public static String migrate(String cHost, int cPort, String cKey, int cDestinationDb, int cTimeout) {
        Jedis tJedis = RedisPool.getJedis();
        String tMigrate = tJedis.migrate(cHost, cPort, cKey, cDestinationDb, cTimeout);
        tJedis.close();
        return tMigrate;
    }

    public static ScanResult<String> scan(String cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<String> tScan = tJedis.scan(cCursor);
        tJedis.close();
        return tScan;
    }

    public static ScanResult<String> scan(String cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<String> tScan = tJedis.scan(cCursor, cParams);
        tJedis.close();
        return tScan;
    }

    public static ScanResult<Entry<String, String>> hscan(String cKey, String cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Entry<String, String>> tHscan = tJedis.hscan(cKey, cCursor);
        tJedis.close();
        return tHscan;
    }

    public static ScanResult<Entry<String, String>> hscan(String cKey, String cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Entry<String, String>> tHscan = tJedis.hscan(cKey, cCursor, cParams);
        tJedis.close();
        return tHscan;
    }

    public static ScanResult<String> sscan(String cKey, String cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<String> tSscan = tJedis.sscan(cKey, cCursor);
        tJedis.close();
        return tSscan;
    }

    public static ScanResult<String> sscan(String cKey, String cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<String> tSscan = tJedis.sscan(cKey, cCursor, cParams);
        tJedis.close();
        return tSscan;
    }

    public static ScanResult<Tuple> zscan(String cKey, String cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Tuple> tZscan = tJedis.zscan(cKey, cCursor);
        tJedis.close();
        return tZscan;
    }

    public static ScanResult<Tuple> zscan(String cKey, String cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Tuple> tZscan = tJedis.zscan(cKey, cCursor, cParams);
        tJedis.close();
        return tZscan;
    }

    public static String clusterNodes() {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterNodes = tJedis.clusterNodes();
        tJedis.close();
        return tClusterNodes;
    }

    public static String readonly() {
        Jedis tJedis = RedisPool.getJedis();
        String tReadonly = tJedis.readonly();
        tJedis.close();
        return tReadonly;
    }

    public static String clusterMeet(String cIp, int cPort) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterMeet = tJedis.clusterMeet(cIp, cPort);
        tJedis.close();
        return tClusterMeet;
    }

    public static String clusterReset(Reset cResetType) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterReset = tJedis.clusterReset(cResetType);
        tJedis.close();
        return tClusterReset;
    }

    public static String clusterAddSlots(int... cSlots) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterAddSlots = tJedis.clusterAddSlots(cSlots);
        tJedis.close();
        return tClusterAddSlots;
    }

    public static String clusterDelSlots(int... cSlots) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterDelSlots = tJedis.clusterDelSlots(cSlots);
        tJedis.close();
        return tClusterDelSlots;
    }

    public static String clusterInfo() {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterInfo = tJedis.clusterInfo();
        tJedis.close();
        return tClusterInfo;
    }

    public static List<String> clusterGetKeysInSlot(int cSlot, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tClusterGetKeysInSlot = tJedis.clusterGetKeysInSlot(cSlot, cCount);
        tJedis.close();
        return tClusterGetKeysInSlot;
    }

    public static String clusterSetSlotNode(int cSlot, String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterSetSlotNode = tJedis.clusterSetSlotNode(cSlot, cNodeId);
        tJedis.close();
        return tClusterSetSlotNode;
    }

    public static String clusterSetSlotMigrating(int cSlot, String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterSetSlotMigrating = tJedis.clusterSetSlotMigrating(cSlot, cNodeId);
        tJedis.close();
        return tClusterSetSlotMigrating;
    }

    public static String clusterSetSlotImporting(int cSlot, String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterSetSlotImporting = tJedis.clusterSetSlotImporting(cSlot, cNodeId);
        tJedis.close();
        return tClusterSetSlotImporting;
    }

    public static String clusterSetSlotStable(int cSlot) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterSetSlotStable = tJedis.clusterSetSlotStable(cSlot);
        tJedis.close();
        return tClusterSetSlotStable;
    }

    public static String clusterForget(String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterForget = tJedis.clusterForget(cNodeId);
        tJedis.close();
        return tClusterForget;
    }

    public static String clusterFlushSlots() {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterFlushSlots = tJedis.clusterFlushSlots();
        tJedis.close();
        return tClusterFlushSlots;
    }

    public static Long clusterKeySlot(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tClusterKeySlot = tJedis.clusterKeySlot(cKey);
        tJedis.close();
        return tClusterKeySlot;
    }

    public static Long clusterCountKeysInSlot(int cSlot) {
        Jedis tJedis = RedisPool.getJedis();
        Long tClusterCountKeysInSlot = tJedis.clusterCountKeysInSlot(cSlot);
        tJedis.close();
        return tClusterCountKeysInSlot;
    }

    public static String clusterSaveConfig() {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterSaveConfig = tJedis.clusterSaveConfig();
        tJedis.close();
        return tClusterSaveConfig;
    }

    public static String clusterReplicate(String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterReplicate = tJedis.clusterReplicate(cNodeId);
        tJedis.close();
        return tClusterReplicate;
    }

    public static List<String> clusterSlaves(String cNodeId) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tClusterSlaves = tJedis.clusterSlaves(cNodeId);
        tJedis.close();
        return tClusterSlaves;
    }

    public static String clusterFailover() {
        Jedis tJedis = RedisPool.getJedis();
        String tClusterFailover = tJedis.clusterFailover();
        tJedis.close();
        return tClusterFailover;
    }

    public static List<Object> clusterSlots() {
        Jedis tJedis = RedisPool.getJedis();
        List<Object> tClusterSlots = tJedis.clusterSlots();
        tJedis.close();
        return tClusterSlots;
    }

    public static String asking() {
        Jedis tJedis = RedisPool.getJedis();
        String tAsking = tJedis.asking();
        tJedis.close();
        return tAsking;
    }

    public static List<String> pubsubChannels(String cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tPubsubChannels = tJedis.pubsubChannels(cPattern);
        tJedis.close();
        return tPubsubChannels;
    }

    public static Long pubsubNumPat() {
        Jedis tJedis = RedisPool.getJedis();
        Long tPubsubNumPat = tJedis.pubsubNumPat();
        tJedis.close();
        return tPubsubNumPat;
    }

    public static Map<String, String> pubsubNumSub(String... cChannels) {
        Jedis tJedis = RedisPool.getJedis();
        Map<String, String> tPubsubNumSub = tJedis.pubsubNumSub(cChannels);
        tJedis.close();
        return tPubsubNumSub;
    }

    public static void close() {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.close();
    }

    public static void setDataSource(Pool<Jedis> cJedisPool) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.setDataSource(cJedisPool);
    }

    public static Long pfadd(String cKey, String... cElements) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPfadd = tJedis.pfadd(cKey, cElements);
        tJedis.close();
        return tPfadd;
    }

    public static long pfcount(String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        long tPfcount = tJedis.pfcount(cKey);
        tJedis.close();
        return tPfcount;
    }

    public static long pfcount(String... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        long tPfcount = tJedis.pfcount(cKeys);
        tJedis.close();
        return tPfcount;
    }

    public static String pfmerge(String cDestkey, String... cSourcekeys) {
        Jedis tJedis = RedisPool.getJedis();
        String tPfmerge = tJedis.pfmerge(cDestkey, cSourcekeys);
        tJedis.close();
        return tPfmerge;
    }

    public static List<String> blpop(int cTimeout, String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBlpop = tJedis.blpop(cTimeout, cKey);
        tJedis.close();
        return tBlpop;
    }

    public static List<String> brpop(int cTimeout, String cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tBrpop = tJedis.brpop(cTimeout, cKey);
        tJedis.close();
        return tBrpop;
    }

    public static Long geoadd(String cKey, double cLongitude, double cLatitude, String cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tGeoadd = tJedis.geoadd(cKey, cLongitude, cLatitude, cMember);
        tJedis.close();
        return tGeoadd;
    }

    public static Long geoadd(String cKey, Map<String, GeoCoordinate> cMemberCoordinateMap) {
        Jedis tJedis = RedisPool.getJedis();
        Long tGeoadd = tJedis.geoadd(cKey, cMemberCoordinateMap);
        tJedis.close();
        return tGeoadd;
    }

    public static Double geodist(String cKey, String cMember1, String cMember2) {
        Jedis tJedis = RedisPool.getJedis();
        Double tGeodist = tJedis.geodist(cKey, cMember1, cMember2);
        tJedis.close();
        return tGeodist;
    }

    public static Double geodist(String cKey, String cMember1, String cMember2, GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        Double tGeodist = tJedis.geodist(cKey, cMember1, cMember2, cUnit);
        tJedis.close();
        return tGeodist;
    }

    public static List<String> geohash(String cKey, String... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tGeohash = tJedis.geohash(cKey, cMembers);
        tJedis.close();
        return tGeohash;
    }

    public static List<GeoCoordinate> geopos(String cKey, String... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoCoordinate> tGeopos = tJedis.geopos(cKey, cMembers);
        tJedis.close();
        return tGeopos;
    }

    public static List<GeoRadiusResponse> georadius(String cKey, double cLongitude, double cLatitude, double cRadius,
            GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradius = tJedis.georadius(cKey, cLongitude, cLatitude, cRadius, cUnit);
        tJedis.close();
        return tGeoradius;
    }

    public static List<GeoRadiusResponse> georadius(String cKey, double cLongitude, double cLatitude, double cRadius,
            GeoUnit cUnit, GeoRadiusParam cParam) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradius = tJedis.georadius(cKey, cLongitude, cLatitude, cRadius, cUnit, cParam);
        tJedis.close();
        return tGeoradius;
    }

    public static List<GeoRadiusResponse> georadiusByMember(String cKey, String cMember, double cRadius,
            GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradiusByMember = tJedis.georadiusByMember(cKey, cMember, cRadius, cUnit);
        tJedis.close();
        return tGeoradiusByMember;
    }

    public static List<GeoRadiusResponse> georadiusByMember(String cKey, String cMember, double cRadius, GeoUnit cUnit,
            GeoRadiusParam cParam) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradiusByMember = tJedis.georadiusByMember(cKey, cMember, cRadius, cUnit, cParam);
        tJedis.close();
        return tGeoradiusByMember;
    }

    public static String ping() {
        Jedis tJedis = RedisPool.getJedis();
        String tPing = tJedis.ping();
        tJedis.close();
        return tPing;
    }

    public static String set(byte[] cKey, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue);
        tJedis.close();
        return tSet;
    }

    public static String set(byte[] cKey, byte[] cValue, byte[] cNxxx, byte[] cExpx, long cTime) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx, cExpx, cTime);
        tJedis.close();
        return tSet;
    }

    public static byte[] get(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tGet = tJedis.get(cKey);
        tJedis.close();
        return tGet;
    }

    public static String quit() {
        Jedis tJedis = RedisPool.getJedis();
        String tQuit = tJedis.quit();
        tJedis.close();
        return tQuit;
    }

    public static Long exists(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExists = tJedis.exists(cKeys);
        tJedis.close();
        return tExists;
    }

    public static Boolean exists(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tExists = tJedis.exists(cKey);
        tJedis.close();
        return tExists;
    }

    public static Long del(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDel = tJedis.del(cKeys);
        tJedis.close();
        return tDel;
    }

    public static Long del(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDel = tJedis.del(cKey);
        tJedis.close();
        return tDel;
    }

    public static String type(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        String tType = tJedis.type(cKey);
        tJedis.close();
        return tType;
    }

    public static String flushDB() {
        Jedis tJedis = RedisPool.getJedis();
        String tFlushDB = tJedis.flushDB();
        tJedis.close();
        return tFlushDB;
    }

    public static Set<byte[]> keys(byte[] cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tKeys = tJedis.keys(cPattern);
        tJedis.close();
        return tKeys;
    }

    public static byte[] randomBinaryKey() {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tRandomBinaryKey = tJedis.randomBinaryKey();
        tJedis.close();
        return tRandomBinaryKey;
    }

    public static String rename(byte[] cOldkey, byte[] cNewkey) {
        Jedis tJedis = RedisPool.getJedis();
        String tRename = tJedis.rename(cOldkey, cNewkey);
        tJedis.close();
        return tRename;
    }

    public static Long renamenx(byte[] cOldkey, byte[] cNewkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRenamenx = tJedis.renamenx(cOldkey, cNewkey);
        tJedis.close();
        return tRenamenx;
    }

    public static Long dbSize() {
        Jedis tJedis = RedisPool.getJedis();
        Long tDbSize = tJedis.dbSize();
        tJedis.close();
        return tDbSize;
    }

    public static Long expire(byte[] cKey, int cSeconds) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExpire = tJedis.expire(cKey, cSeconds);
        tJedis.close();
        return tExpire;
    }

    public static Long expireAt(byte[] cKey, long cUnixTime) {
        Jedis tJedis = RedisPool.getJedis();
        Long tExpireAt = tJedis.expireAt(cKey, cUnixTime);
        tJedis.close();
        return tExpireAt;
    }

    public static Long ttl(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tTtl = tJedis.ttl(cKey);
        tJedis.close();
        return tTtl;
    }

    public static String select(int cIndex) {
        Jedis tJedis = RedisPool.getJedis();
        String tSelect = tJedis.select(cIndex);
        tJedis.close();
        return tSelect;
    }

    public static Long move(byte[] cKey, int cDbIndex) {
        Jedis tJedis = RedisPool.getJedis();
        Long tMove = tJedis.move(cKey, cDbIndex);
        tJedis.close();
        return tMove;
    }

    public static String flushAll() {
        Jedis tJedis = RedisPool.getJedis();
        String tFlushAll = tJedis.flushAll();
        tJedis.close();
        return tFlushAll;
    }

    public static byte[] getSet(byte[] cKey, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tGetSet = tJedis.getSet(cKey, cValue);
        tJedis.close();
        return tGetSet;
    }

    public static List<byte[]> mget(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tMget = tJedis.mget(cKeys);
        tJedis.close();
        return tMget;
    }

    public static Long setnx(byte[] cKey, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSetnx = tJedis.setnx(cKey, cValue);
        tJedis.close();
        return tSetnx;
    }

    public static String setex(byte[] cKey, int cSeconds, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tSetex = tJedis.setex(cKey, cSeconds, cValue);
        tJedis.close();
        return tSetex;
    }

    public static String mset(byte[]... cKeysvalues) {
        Jedis tJedis = RedisPool.getJedis();
        String tMset = tJedis.mset(cKeysvalues);
        tJedis.close();
        return tMset;
    }

    public static Long msetnx(byte[]... cKeysvalues) {
        Jedis tJedis = RedisPool.getJedis();
        Long tMsetnx = tJedis.msetnx(cKeysvalues);
        tJedis.close();
        return tMsetnx;
    }

    public static Long decrBy(byte[] cKey, long cInteger) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDecrBy = tJedis.decrBy(cKey, cInteger);
        tJedis.close();
        return tDecrBy;
    }

    public static Long decr(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tDecr = tJedis.decr(cKey);
        tJedis.close();
        return tDecr;
    }

    public static Long incrBy(byte[] cKey, long cInteger) {
        Jedis tJedis = RedisPool.getJedis();
        Long tIncrBy = tJedis.incrBy(cKey, cInteger);
        tJedis.close();
        return tIncrBy;
    }

    public static Double incrByFloat(byte[] cKey, double cInteger) {
        Jedis tJedis = RedisPool.getJedis();
        Double tIncrByFloat = tJedis.incrByFloat(cKey, cInteger);
        tJedis.close();
        return tIncrByFloat;
    }

    public static Long incr(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tIncr = tJedis.incr(cKey);
        tJedis.close();
        return tIncr;
    }

    public static Long append(byte[] cKey, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tAppend = tJedis.append(cKey, cValue);
        tJedis.close();
        return tAppend;
    }

    public static byte[] substr(byte[] cKey, int cStart, int cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tSubstr = tJedis.substr(cKey, cStart, cEnd);
        tJedis.close();
        return tSubstr;
    }

    public static Long hset(byte[] cKey, byte[] cField, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHset = tJedis.hset(cKey, cField, cValue);
        tJedis.close();
        return tHset;
    }

    public static byte[] hget(byte[] cKey, byte[] cField) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tHget = tJedis.hget(cKey, cField);
        tJedis.close();
        return tHget;
    }

    public static Long hsetnx(byte[] cKey, byte[] cField, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHsetnx = tJedis.hsetnx(cKey, cField, cValue);
        tJedis.close();
        return tHsetnx;
    }

    public static String hmset(byte[] cKey, Map<byte[], byte[]> cHash) {
        Jedis tJedis = RedisPool.getJedis();
        String tHmset = tJedis.hmset(cKey, cHash);
        tJedis.close();
        return tHmset;
    }

    public static List<byte[]> hmget(byte[] cKey, byte[]... cFields) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tHmget = tJedis.hmget(cKey, cFields);
        tJedis.close();
        return tHmget;
    }

    public static Long hincrBy(byte[] cKey, byte[] cField, long cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHincrBy = tJedis.hincrBy(cKey, cField, cValue);
        tJedis.close();
        return tHincrBy;
    }

    public static Double hincrByFloat(byte[] cKey, byte[] cField, double cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Double tHincrByFloat = tJedis.hincrByFloat(cKey, cField, cValue);
        tJedis.close();
        return tHincrByFloat;
    }

    public static Boolean hexists(byte[] cKey, byte[] cField) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tHexists = tJedis.hexists(cKey, cField);
        tJedis.close();
        return tHexists;
    }

    public static Long hdel(byte[] cKey, byte[]... cFields) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHdel = tJedis.hdel(cKey, cFields);
        tJedis.close();
        return tHdel;
    }

    public static Long hlen(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tHlen = tJedis.hlen(cKey);
        tJedis.close();
        return tHlen;
    }

    public static Set<byte[]> hkeys(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tHkeys = tJedis.hkeys(cKey);
        tJedis.close();
        return tHkeys;
    }

    public static List<byte[]> hvals(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tHvals = tJedis.hvals(cKey);
        tJedis.close();
        return tHvals;
    }

    public static Map<byte[], byte[]> hgetAll(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Map<byte[], byte[]> tHgetAll = tJedis.hgetAll(cKey);
        tJedis.close();
        return tHgetAll;
    }

    public static Long rpush(byte[] cKey, byte[]... cStrings) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRpush = tJedis.rpush(cKey, cStrings);
        tJedis.close();
        return tRpush;
    }

    public static Long lpush(byte[] cKey, byte[]... cStrings) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLpush = tJedis.lpush(cKey, cStrings);
        tJedis.close();
        return tLpush;
    }

    public static Long llen(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLlen = tJedis.llen(cKey);
        tJedis.close();
        return tLlen;
    }

    public static List<byte[]> lrange(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tLrange = tJedis.lrange(cKey, cStart, cEnd);
        tJedis.close();
        return tLrange;
    }

    public static String ltrim(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        String tLtrim = tJedis.ltrim(cKey, cStart, cEnd);
        tJedis.close();
        return tLtrim;
    }

    public static byte[] lindex(byte[] cKey, long cIndex) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tLindex = tJedis.lindex(cKey, cIndex);
        tJedis.close();
        return tLindex;
    }

    public static String lset(byte[] cKey, long cIndex, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tLset = tJedis.lset(cKey, cIndex, cValue);
        tJedis.close();
        return tLset;
    }

    public static Long lrem(byte[] cKey, long cCount, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLrem = tJedis.lrem(cKey, cCount, cValue);
        tJedis.close();
        return tLrem;
    }

    public static byte[] lpop(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tLpop = tJedis.lpop(cKey);
        tJedis.close();
        return tLpop;
    }

    public static byte[] rpop(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tRpop = tJedis.rpop(cKey);
        tJedis.close();
        return tRpop;
    }

    public static byte[] rpoplpush(byte[] cSrckey, byte[] cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tRpoplpush = tJedis.rpoplpush(cSrckey, cDstkey);
        tJedis.close();
        return tRpoplpush;
    }

    public static Long sadd(byte[] cKey, byte[]... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSadd = tJedis.sadd(cKey, cMembers);
        tJedis.close();
        return tSadd;
    }

    public static Set<byte[]> smembers(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tSmembers = tJedis.smembers(cKey);
        tJedis.close();
        return tSmembers;
    }

    public static Long srem(byte[] cKey, byte[]... cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSrem = tJedis.srem(cKey, cMember);
        tJedis.close();
        return tSrem;
    }

    public static byte[] spop(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tSpop = tJedis.spop(cKey);
        tJedis.close();
        return tSpop;
    }

    public static Set<byte[]> spop(byte[] cKey, long cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tSpop = tJedis.spop(cKey, cCount);
        tJedis.close();
        return tSpop;
    }

    public static Long smove(byte[] cSrckey, byte[] cDstkey, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSmove = tJedis.smove(cSrckey, cDstkey, cMember);
        tJedis.close();
        return tSmove;
    }

    public static Long scard(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tScard = tJedis.scard(cKey);
        tJedis.close();
        return tScard;
    }

    public static Boolean sismember(byte[] cKey, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSismember = tJedis.sismember(cKey, cMember);
        tJedis.close();
        return tSismember;
    }

    public static Set<byte[]> sinter(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tSinter = tJedis.sinter(cKeys);
        tJedis.close();
        return tSinter;
    }

    public static Long sinterstore(byte[] cDstkey, byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSinterstore = tJedis.sinterstore(cDstkey, cKeys);
        tJedis.close();
        return tSinterstore;
    }

    public static Set<byte[]> sunion(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tSunion = tJedis.sunion(cKeys);
        tJedis.close();
        return tSunion;
    }

    public static Long sunionstore(byte[] cDstkey, byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSunionstore = tJedis.sunionstore(cDstkey, cKeys);
        tJedis.close();
        return tSunionstore;
    }

    public static Set<byte[]> sdiff(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tSdiff = tJedis.sdiff(cKeys);
        tJedis.close();
        return tSdiff;
    }

    public static Long sdiffstore(byte[] cDstkey, byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSdiffstore = tJedis.sdiffstore(cDstkey, cKeys);
        tJedis.close();
        return tSdiffstore;
    }

    public static byte[] srandmember(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tSrandmember = tJedis.srandmember(cKey);
        tJedis.close();
        return tSrandmember;
    }

    public static List<byte[]> srandmember(byte[] cKey, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tSrandmember = tJedis.srandmember(cKey, cCount);
        tJedis.close();
        return tSrandmember;
    }

    public static Long zadd(byte[] cKey, double cScore, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScore, cMember);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(byte[] cKey, double cScore, byte[] cMember, ZAddParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScore, cMember, cParams);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(byte[] cKey, Map<byte[], Double> cScoreMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScoreMembers);
        tJedis.close();
        return tZadd;
    }

    public static Long zadd(byte[] cKey, Map<byte[], Double> cScoreMembers, ZAddParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZadd = tJedis.zadd(cKey, cScoreMembers, cParams);
        tJedis.close();
        return tZadd;
    }

    public static Set<byte[]> zrange(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrange = tJedis.zrange(cKey, cStart, cEnd);
        tJedis.close();
        return tZrange;
    }

    public static Long zrem(byte[] cKey, byte[]... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrem = tJedis.zrem(cKey, cMembers);
        tJedis.close();
        return tZrem;
    }

    public static Double zincrby(byte[] cKey, double cScore, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZincrby = tJedis.zincrby(cKey, cScore, cMember);
        tJedis.close();
        return tZincrby;
    }

    public static Double zincrby(byte[] cKey, double cScore, byte[] cMember, ZIncrByParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZincrby = tJedis.zincrby(cKey, cScore, cMember, cParams);
        tJedis.close();
        return tZincrby;
    }

    public static Long zrank(byte[] cKey, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrank = tJedis.zrank(cKey, cMember);
        tJedis.close();
        return tZrank;
    }

    public static Long zrevrank(byte[] cKey, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZrevrank = tJedis.zrevrank(cKey, cMember);
        tJedis.close();
        return tZrevrank;
    }

    public static Set<byte[]> zrevrange(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrange = tJedis.zrevrange(cKey, cStart, cEnd);
        tJedis.close();
        return tZrevrange;
    }

    public static Set<Tuple> zrangeWithScores(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeWithScores = tJedis.zrangeWithScores(cKey, cStart, cEnd);
        tJedis.close();
        return tZrangeWithScores;
    }

    public static Set<Tuple> zrevrangeWithScores(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeWithScores = tJedis.zrevrangeWithScores(cKey, cStart, cEnd);
        tJedis.close();
        return tZrevrangeWithScores;
    }

    public static Long zcard(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcard = tJedis.zcard(cKey);
        tJedis.close();
        return tZcard;
    }

    public static Double zscore(byte[] cKey, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Double tZscore = tJedis.zscore(cKey, cMember);
        tJedis.close();
        return tZscore;
    }

    public static Transaction multi() {
        Jedis tJedis = RedisPool.getJedis();
        Transaction tMulti = tJedis.multi();
        tJedis.close();
        return tMulti;
    }

    public static void connect() {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.connect();
    }

    public static void disconnect() {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.disconnect();
    }

    public static void resetState() {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.resetState();
    }

    public static String watch(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        String tWatch = tJedis.watch(cKeys);
        tJedis.close();
        return tWatch;
    }

    public static String unwatch() {
        Jedis tJedis = RedisPool.getJedis();
        String tUnwatch = tJedis.unwatch();
        tJedis.close();
        return tUnwatch;
    }

    public static List<byte[]> sort(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tSort = tJedis.sort(cKey);
        tJedis.close();
        return tSort;
    }

    public static List<byte[]> sort(byte[] cKey, SortingParams cSortingParameters) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tSort = tJedis.sort(cKey, cSortingParameters);
        tJedis.close();
        return tSort;
    }

    public static List<byte[]> blpop(int cTimeout, byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tBlpop = tJedis.blpop(cTimeout, cKeys);
        tJedis.close();
        return tBlpop;
    }

    public static Long sort(byte[] cKey, SortingParams cSortingParameters, byte[] cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSort = tJedis.sort(cKey, cSortingParameters, cDstkey);
        tJedis.close();
        return tSort;
    }

    public static Long sort(byte[] cKey, byte[] cDstkey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSort = tJedis.sort(cKey, cDstkey);
        tJedis.close();
        return tSort;
    }

    public static List<byte[]> brpop(int cTimeout, byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tBrpop = tJedis.brpop(cTimeout, cKeys);
        tJedis.close();
        return tBrpop;
    }

    public static List<byte[]> blpop(byte[]... cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tBlpop = tJedis.blpop(cArgs);
        tJedis.close();
        return tBlpop;
    }

    public static List<byte[]> brpop(byte[]... cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tBrpop = tJedis.brpop(cArgs);
        tJedis.close();
        return tBrpop;
    }

    public static String auth(String cPassword) {
        Jedis tJedis = RedisPool.getJedis();
        String tAuth = tJedis.auth(cPassword);
        tJedis.close();
        return tAuth;
    }

    public static Pipeline pipelined() {
        Jedis tJedis = RedisPool.getJedis();
        Pipeline tPipelined = tJedis.pipelined();
        tJedis.close();
        return tPipelined;
    }

    public static Long zcount(byte[] cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcount = tJedis.zcount(cKey, cMin, cMax);
        tJedis.close();
        return tZcount;
    }

    public static Long zcount(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZcount = tJedis.zcount(cKey, cMin, cMax);
        tJedis.close();
        return tZcount;
    }

    public static Set<byte[]> zrangeByScore(byte[] cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<byte[]> zrangeByScore(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<byte[]> zrangeByScore(byte[] cKey, double cMin, double cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<byte[]> zrangeByScore(byte[] cKey, byte[] cMin, byte[] cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByScore = tJedis.zrangeByScore(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScore;
    }

    public static Set<Tuple> zrangeByScoreWithScores(byte[] cKey, double cMin, double cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(byte[] cKey, double cMin, double cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<Tuple> zrangeByScoreWithScores(byte[] cKey, byte[] cMin, byte[] cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrangeByScoreWithScores = tJedis.zrangeByScoreWithScores(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByScoreWithScores;
    }

    public static Set<byte[]> zrevrangeByScore(byte[] cKey, double cMax, double cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<byte[]> zrevrangeByScore(byte[] cKey, byte[] cMax, byte[] cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<byte[]> zrevrangeByScore(byte[] cKey, double cMax, double cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<byte[]> zrevrangeByScore(byte[] cKey, byte[] cMax, byte[] cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByScore = tJedis.zrevrangeByScore(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScore;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(byte[] cKey, double cMax, double cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(byte[] cKey, double cMax, double cMin, int cOffset,
            int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(byte[] cKey, byte[] cMax, byte[] cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Set<Tuple> zrevrangeByScoreWithScores(byte[] cKey, byte[] cMax, byte[] cMin, int cOffset,
            int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<Tuple> tZrevrangeByScoreWithScores = tJedis.zrevrangeByScoreWithScores(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByScoreWithScores;
    }

    public static Long zremrangeByRank(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByRank = tJedis.zremrangeByRank(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByRank;
    }

    public static Long zremrangeByScore(byte[] cKey, double cStart, double cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByScore = tJedis.zremrangeByScore(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByScore;
    }

    public static Long zremrangeByScore(byte[] cKey, byte[] cStart, byte[] cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByScore = tJedis.zremrangeByScore(cKey, cStart, cEnd);
        tJedis.close();
        return tZremrangeByScore;
    }

    public static Long zunionstore(byte[] cDstkey, byte[]... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZunionstore = tJedis.zunionstore(cDstkey, cSets);
        tJedis.close();
        return tZunionstore;
    }

    public static Long zunionstore(byte[] cDstkey, ZParams cParams, byte[]... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZunionstore = tJedis.zunionstore(cDstkey, cParams, cSets);
        tJedis.close();
        return tZunionstore;
    }

    public static Long zinterstore(byte[] cDstkey, byte[]... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZinterstore = tJedis.zinterstore(cDstkey, cSets);
        tJedis.close();
        return tZinterstore;
    }

    public static Long zinterstore(byte[] cDstkey, ZParams cParams, byte[]... cSets) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZinterstore = tJedis.zinterstore(cDstkey, cParams, cSets);
        tJedis.close();
        return tZinterstore;
    }

    public static Long zlexcount(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZlexcount = tJedis.zlexcount(cKey, cMin, cMax);
        tJedis.close();
        return tZlexcount;
    }

    public static Set<byte[]> zrangeByLex(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByLex = tJedis.zrangeByLex(cKey, cMin, cMax);
        tJedis.close();
        return tZrangeByLex;
    }

    public static Set<byte[]> zrangeByLex(byte[] cKey, byte[] cMin, byte[] cMax, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrangeByLex = tJedis.zrangeByLex(cKey, cMin, cMax, cOffset, cCount);
        tJedis.close();
        return tZrangeByLex;
    }

    public static Set<byte[]> zrevrangeByLex(byte[] cKey, byte[] cMax, byte[] cMin) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByLex = tJedis.zrevrangeByLex(cKey, cMax, cMin);
        tJedis.close();
        return tZrevrangeByLex;
    }

    public static Set<byte[]> zrevrangeByLex(byte[] cKey, byte[] cMax, byte[] cMin, int cOffset, int cCount) {
        Jedis tJedis = RedisPool.getJedis();
        Set<byte[]> tZrevrangeByLex = tJedis.zrevrangeByLex(cKey, cMax, cMin, cOffset, cCount);
        tJedis.close();
        return tZrevrangeByLex;
    }

    public static Long zremrangeByLex(byte[] cKey, byte[] cMin, byte[] cMax) {
        Jedis tJedis = RedisPool.getJedis();
        Long tZremrangeByLex = tJedis.zremrangeByLex(cKey, cMin, cMax);
        tJedis.close();
        return tZremrangeByLex;
    }

    public static String save() {
        Jedis tJedis = RedisPool.getJedis();
        String tSave = tJedis.save();
        tJedis.close();
        return tSave;
    }

    public static String bgsave() {
        Jedis tJedis = RedisPool.getJedis();
        String tBgsave = tJedis.bgsave();
        tJedis.close();
        return tBgsave;
    }

    public static String bgrewriteaof() {
        Jedis tJedis = RedisPool.getJedis();
        String tBgrewriteaof = tJedis.bgrewriteaof();
        tJedis.close();
        return tBgrewriteaof;
    }

    public static Long lastsave() {
        Jedis tJedis = RedisPool.getJedis();
        Long tLastsave = tJedis.lastsave();
        tJedis.close();
        return tLastsave;
    }

    public static String shutdown() {
        Jedis tJedis = RedisPool.getJedis();
        String tShutdown = tJedis.shutdown();
        tJedis.close();
        return tShutdown;
    }

    public static String info() {
        Jedis tJedis = RedisPool.getJedis();
        String tInfo = tJedis.info();
        tJedis.close();
        return tInfo;
    }

    public static String info(String cSection) {
        Jedis tJedis = RedisPool.getJedis();
        String tInfo = tJedis.info(cSection);
        tJedis.close();
        return tInfo;
    }

    public static void monitor(JedisMonitor cJedisMonitor) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.monitor(cJedisMonitor);
    }

    public static String slaveof(String cHost, int cPort) {
        Jedis tJedis = RedisPool.getJedis();
        String tSlaveof = tJedis.slaveof(cHost, cPort);
        tJedis.close();
        return tSlaveof;
    }

    public static String slaveofNoOne() {
        Jedis tJedis = RedisPool.getJedis();
        String tSlaveofNoOne = tJedis.slaveofNoOne();
        tJedis.close();
        return tSlaveofNoOne;
    }

    public static List<byte[]> configGet(byte[] cPattern) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tConfigGet = tJedis.configGet(cPattern);
        tJedis.close();
        return tConfigGet;
    }

    public static String configResetStat() {
        Jedis tJedis = RedisPool.getJedis();
        String tConfigResetStat = tJedis.configResetStat();
        tJedis.close();
        return tConfigResetStat;
    }

    public static byte[] configSet(byte[] cParameter, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tConfigSet = tJedis.configSet(cParameter, cValue);
        tJedis.close();
        return tConfigSet;
    }

    public static boolean isConnected() {
        Jedis tJedis = RedisPool.getJedis();
        boolean tIsConnected = tJedis.isConnected();
        tJedis.close();
        return tIsConnected;
    }

    public static Long strlen(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tStrlen = tJedis.strlen(cKey);
        tJedis.close();
        return tStrlen;
    }

    public static void sync() {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.sync();
    }

    public static Long lpushx(byte[] cKey, byte[]... cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLpushx = tJedis.lpushx(cKey, cString);
        tJedis.close();
        return tLpushx;
    }

    public static Long persist(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPersist = tJedis.persist(cKey);
        tJedis.close();
        return tPersist;
    }

    public static Long rpushx(byte[] cKey, byte[]... cString) {
        Jedis tJedis = RedisPool.getJedis();
        Long tRpushx = tJedis.rpushx(cKey, cString);
        tJedis.close();
        return tRpushx;
    }

    public static byte[] echo(byte[] cString) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tEcho = tJedis.echo(cString);
        tJedis.close();
        return tEcho;
    }

    public static Long linsert(byte[] cKey, LIST_POSITION cWhere, byte[] cPivot, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tLinsert = tJedis.linsert(cKey, cWhere, cPivot, cValue);
        tJedis.close();
        return tLinsert;
    }

    public static String debug(DebugParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        String tDebug = tJedis.debug(cParams);
        tJedis.close();
        return tDebug;
    }

    public static Client getClient() {
        Jedis tJedis = RedisPool.getJedis();
        Client tGetClient = tJedis.getClient();
        tJedis.close();
        return tGetClient;
    }

    public static byte[] brpoplpush(byte[] cSource, byte[] cDestination, int cTimeout) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tBrpoplpush = tJedis.brpoplpush(cSource, cDestination, cTimeout);
        tJedis.close();
        return tBrpoplpush;
    }

    public static Boolean setbit(byte[] cKey, long cOffset, boolean cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSetbit = tJedis.setbit(cKey, cOffset, cValue);
        tJedis.close();
        return tSetbit;
    }

    public static Boolean setbit(byte[] cKey, long cOffset, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tSetbit = tJedis.setbit(cKey, cOffset, cValue);
        tJedis.close();
        return tSetbit;
    }

    public static Boolean getbit(byte[] cKey, long cOffset) {
        Jedis tJedis = RedisPool.getJedis();
        Boolean tGetbit = tJedis.getbit(cKey, cOffset);
        tJedis.close();
        return tGetbit;
    }

    public static Long bitpos(byte[] cKey, boolean cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitpos = tJedis.bitpos(cKey, cValue);
        tJedis.close();
        return tBitpos;
    }

    public static Long bitpos(byte[] cKey, boolean cValue, BitPosParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitpos = tJedis.bitpos(cKey, cValue, cParams);
        tJedis.close();
        return tBitpos;
    }

    public static Long setrange(byte[] cKey, long cOffset, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        Long tSetrange = tJedis.setrange(cKey, cOffset, cValue);
        tJedis.close();
        return tSetrange;
    }

    public static byte[] getrange(byte[] cKey, long cStartOffset, long cEndOffset) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tGetrange = tJedis.getrange(cKey, cStartOffset, cEndOffset);
        tJedis.close();
        return tGetrange;
    }

    public static Long publish(byte[] cChannel, byte[] cMessage) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPublish = tJedis.publish(cChannel, cMessage);
        tJedis.close();
        return tPublish;
    }

    public static void subscribe(BinaryJedisPubSub cJedisPubSub, byte[]... cChannels) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.subscribe(cJedisPubSub, cChannels);
    }

    public static void psubscribe(BinaryJedisPubSub cJedisPubSub, byte[]... cPatterns) {
        Jedis tJedis = RedisPool.getJedis();
        tJedis.psubscribe(cJedisPubSub, cPatterns);
    }

    public static Long getDB() {
        Jedis tJedis = RedisPool.getJedis();
        Long tGetDB = tJedis.getDB();
        tJedis.close();
        return tGetDB;
    }

    public static Object eval(byte[] cScript, List<byte[]> cKeys, List<byte[]> cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript, cKeys, cArgs);
        tJedis.close();
        return tEval;
    }

    public static Object eval(byte[] cScript, byte[] cKeyCount, byte[]... cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript, cKeyCount, cParams);
        tJedis.close();
        return tEval;
    }

    public static Object eval(byte[] cScript, int cKeyCount, byte[]... cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript, cKeyCount, cParams);
        tJedis.close();
        return tEval;
    }

    public static Object eval(byte[] cScript) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEval = tJedis.eval(cScript);
        tJedis.close();
        return tEval;
    }

    public static Object evalsha(byte[] cSha1) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cSha1);
        tJedis.close();
        return tEvalsha;
    }

    public static Object evalsha(byte[] cSha1, List<byte[]> cKeys, List<byte[]> cArgs) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cSha1, cKeys, cArgs);
        tJedis.close();
        return tEvalsha;
    }

    public static Object evalsha(byte[] cSha1, int cKeyCount, byte[]... cParams) {
        Jedis tJedis = RedisPool.getJedis();
        Object tEvalsha = tJedis.evalsha(cSha1, cKeyCount, cParams);
        tJedis.close();
        return tEvalsha;
    }

    public static String scriptFlush() {
        Jedis tJedis = RedisPool.getJedis();
        String tScriptFlush = tJedis.scriptFlush();
        tJedis.close();
        return tScriptFlush;
    }

    public static Long scriptExists(byte[] cSha1) {
        Jedis tJedis = RedisPool.getJedis();
        Long tScriptExists = tJedis.scriptExists(cSha1);
        tJedis.close();
        return tScriptExists;
    }

    public static List<Long> scriptExists(byte[]... cSha1) {
        Jedis tJedis = RedisPool.getJedis();
        List<Long> tScriptExists = tJedis.scriptExists(cSha1);
        tJedis.close();
        return tScriptExists;
    }

    public static byte[] scriptLoad(byte[] cScript) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tScriptLoad = tJedis.scriptLoad(cScript);
        tJedis.close();
        return tScriptLoad;
    }

    public static String scriptKill() {
        Jedis tJedis = RedisPool.getJedis();
        String tScriptKill = tJedis.scriptKill();
        tJedis.close();
        return tScriptKill;
    }

    public static String slowlogReset() {
        Jedis tJedis = RedisPool.getJedis();
        String tSlowlogReset = tJedis.slowlogReset();
        tJedis.close();
        return tSlowlogReset;
    }

    public static Long slowlogLen() {
        Jedis tJedis = RedisPool.getJedis();
        Long tSlowlogLen = tJedis.slowlogLen();
        tJedis.close();
        return tSlowlogLen;
    }

    public static List<byte[]> slowlogGetBinary() {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tSlowlogGetBinary = tJedis.slowlogGetBinary();
        tJedis.close();
        return tSlowlogGetBinary;
    }

    public static List<byte[]> slowlogGetBinary(long cEntries) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tSlowlogGetBinary = tJedis.slowlogGetBinary(cEntries);
        tJedis.close();
        return tSlowlogGetBinary;
    }

    public static Long objectRefcount(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tObjectRefcount = tJedis.objectRefcount(cKey);
        tJedis.close();
        return tObjectRefcount;
    }

    public static byte[] objectEncoding(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tObjectEncoding = tJedis.objectEncoding(cKey);
        tJedis.close();
        return tObjectEncoding;
    }

    public static Long objectIdletime(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tObjectIdletime = tJedis.objectIdletime(cKey);
        tJedis.close();
        return tObjectIdletime;
    }

    public static Long bitcount(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitcount = tJedis.bitcount(cKey);
        tJedis.close();
        return tBitcount;
    }

    public static Long bitcount(byte[] cKey, long cStart, long cEnd) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitcount = tJedis.bitcount(cKey, cStart, cEnd);
        tJedis.close();
        return tBitcount;
    }

    public static Long bitop(BitOP cOp, byte[] cDestKey, byte[]... cSrcKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tBitop = tJedis.bitop(cOp, cDestKey, cSrcKeys);
        tJedis.close();
        return tBitop;
    }

    public static byte[] dump(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        byte[] tDump = tJedis.dump(cKey);
        tJedis.close();
        return tDump;
    }

    public static String restore(byte[] cKey, int cTtl, byte[] cSerializedValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tRestore = tJedis.restore(cKey, cTtl, cSerializedValue);
        tJedis.close();
        return tRestore;
    }

    public static Long pexpire(byte[] cKey, long cMilliseconds) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPexpire = tJedis.pexpire(cKey, cMilliseconds);
        tJedis.close();
        return tPexpire;
    }

    public static Long pexpireAt(byte[] cKey, long cMillisecondsTimestamp) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPexpireAt = tJedis.pexpireAt(cKey, cMillisecondsTimestamp);
        tJedis.close();
        return tPexpireAt;
    }

    public static Long pttl(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPttl = tJedis.pttl(cKey);
        tJedis.close();
        return tPttl;
    }

    public static String psetex(byte[] cKey, long cMilliseconds, byte[] cValue) {
        Jedis tJedis = RedisPool.getJedis();
        String tPsetex = tJedis.psetex(cKey, cMilliseconds, cValue);
        tJedis.close();
        return tPsetex;
    }

    public static String set(byte[] cKey, byte[] cValue, byte[] cNxxx) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx);
        tJedis.close();
        return tSet;
    }

    public static String set(byte[] cKey, byte[] cValue, byte[] cNxxx, byte[] cExpx, int cTime) {
        Jedis tJedis = RedisPool.getJedis();
        String tSet = tJedis.set(cKey, cValue, cNxxx, cExpx, cTime);
        tJedis.close();
        return tSet;
    }

    public static String clientKill(byte[] cClient) {
        Jedis tJedis = RedisPool.getJedis();
        String tClientKill = tJedis.clientKill(cClient);
        tJedis.close();
        return tClientKill;
    }

    public static String clientGetname() {
        Jedis tJedis = RedisPool.getJedis();
        String tClientGetname = tJedis.clientGetname();
        tJedis.close();
        return tClientGetname;
    }

    public static String clientList() {
        Jedis tJedis = RedisPool.getJedis();
        String tClientList = tJedis.clientList();
        tJedis.close();
        return tClientList;
    }

    public static String clientSetname(byte[] cName) {
        Jedis tJedis = RedisPool.getJedis();
        String tClientSetname = tJedis.clientSetname(cName);
        tJedis.close();
        return tClientSetname;
    }

    public static List<String> time() {
        Jedis tJedis = RedisPool.getJedis();
        List<String> tTime = tJedis.time();
        tJedis.close();
        return tTime;
    }

    public static String migrate(byte[] cHost, int cPort, byte[] cKey, int cDestinationDb, int cTimeout) {
        Jedis tJedis = RedisPool.getJedis();
        String tMigrate = tJedis.migrate(cHost, cPort, cKey, cDestinationDb, cTimeout);
        tJedis.close();
        return tMigrate;
    }

    public static Long waitReplicas(int cReplicas, long cTimeout) {
        Jedis tJedis = RedisPool.getJedis();
        Long tWaitReplicas = tJedis.waitReplicas(cReplicas, cTimeout);
        tJedis.close();
        return tWaitReplicas;
    }

    public static Long pfadd(byte[] cKey, byte[]... cElements) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPfadd = tJedis.pfadd(cKey, cElements);
        tJedis.close();
        return tPfadd;
    }

    public static long pfcount(byte[] cKey) {
        Jedis tJedis = RedisPool.getJedis();
        long tPfcount = tJedis.pfcount(cKey);
        tJedis.close();
        return tPfcount;
    }

    public static String pfmerge(byte[] cDestkey, byte[]... cSourcekeys) {
        Jedis tJedis = RedisPool.getJedis();
        String tPfmerge = tJedis.pfmerge(cDestkey, cSourcekeys);
        tJedis.close();
        return tPfmerge;
    }

    public static Long pfcount(byte[]... cKeys) {
        Jedis tJedis = RedisPool.getJedis();
        Long tPfcount = tJedis.pfcount(cKeys);
        tJedis.close();
        return tPfcount;
    }

    public static ScanResult<byte[]> scan(byte[] cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<byte[]> tScan = tJedis.scan(cCursor);
        tJedis.close();
        return tScan;
    }

    public static ScanResult<byte[]> scan(byte[] cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<byte[]> tScan = tJedis.scan(cCursor, cParams);
        tJedis.close();
        return tScan;
    }

    public static ScanResult<Entry<byte[], byte[]>> hscan(byte[] cKey, byte[] cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Entry<byte[], byte[]>> tHscan = tJedis.hscan(cKey, cCursor);
        tJedis.close();
        return tHscan;
    }

    public static ScanResult<Entry<byte[], byte[]>> hscan(byte[] cKey, byte[] cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Entry<byte[], byte[]>> tHscan = tJedis.hscan(cKey, cCursor, cParams);
        tJedis.close();
        return tHscan;
    }

    public static ScanResult<byte[]> sscan(byte[] cKey, byte[] cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<byte[]> tSscan = tJedis.sscan(cKey, cCursor);
        tJedis.close();
        return tSscan;
    }

    public static ScanResult<byte[]> sscan(byte[] cKey, byte[] cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<byte[]> tSscan = tJedis.sscan(cKey, cCursor, cParams);
        tJedis.close();
        return tSscan;
    }

    public static ScanResult<Tuple> zscan(byte[] cKey, byte[] cCursor) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Tuple> tZscan = tJedis.zscan(cKey, cCursor);
        tJedis.close();
        return tZscan;
    }

    public static ScanResult<Tuple> zscan(byte[] cKey, byte[] cCursor, ScanParams cParams) {
        Jedis tJedis = RedisPool.getJedis();
        ScanResult<Tuple> tZscan = tJedis.zscan(cKey, cCursor, cParams);
        tJedis.close();
        return tZscan;
    }

    public static Long geoadd(byte[] cKey, double cLongitude, double cLatitude, byte[] cMember) {
        Jedis tJedis = RedisPool.getJedis();
        Long tGeoadd = tJedis.geoadd(cKey, cLongitude, cLatitude, cMember);
        tJedis.close();
        return tGeoadd;
    }

    public static Long geoadd(byte[] cKey, Map<byte[], GeoCoordinate> cMemberCoordinateMap) {
        Jedis tJedis = RedisPool.getJedis();
        Long tGeoadd = tJedis.geoadd(cKey, cMemberCoordinateMap);
        tJedis.close();
        return tGeoadd;
    }

    public static Double geodist(byte[] cKey, byte[] cMember1, byte[] cMember2) {
        Jedis tJedis = RedisPool.getJedis();
        Double tGeodist = tJedis.geodist(cKey, cMember1, cMember2);
        tJedis.close();
        return tGeodist;
    }

    public static Double geodist(byte[] cKey, byte[] cMember1, byte[] cMember2, GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        Double tGeodist = tJedis.geodist(cKey, cMember1, cMember2, cUnit);
        tJedis.close();
        return tGeodist;
    }

    public static List<byte[]> geohash(byte[] cKey, byte[]... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        List<byte[]> tGeohash = tJedis.geohash(cKey, cMembers);
        tJedis.close();
        return tGeohash;
    }

    public static List<GeoCoordinate> geopos(byte[] cKey, byte[]... cMembers) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoCoordinate> tGeopos = tJedis.geopos(cKey, cMembers);
        tJedis.close();
        return tGeopos;
    }

    public static List<GeoRadiusResponse> georadius(byte[] cKey, double cLongitude, double cLatitude, double cRadius,
            GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradius = tJedis.georadius(cKey, cLongitude, cLatitude, cRadius, cUnit);
        tJedis.close();
        return tGeoradius;
    }

    public static List<GeoRadiusResponse> georadius(byte[] cKey, double cLongitude, double cLatitude, double cRadius,
            GeoUnit cUnit, GeoRadiusParam cParam) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradius = tJedis.georadius(cKey, cLongitude, cLatitude, cRadius, cUnit, cParam);
        tJedis.close();
        return tGeoradius;
    }

    public static List<GeoRadiusResponse> georadiusByMember(byte[] cKey, byte[] cMember, double cRadius,
            GeoUnit cUnit) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradiusByMember = tJedis.georadiusByMember(cKey, cMember, cRadius, cUnit);
        tJedis.close();
        return tGeoradiusByMember;
    }

    public static List<GeoRadiusResponse> georadiusByMember(byte[] cKey, byte[] cMember, double cRadius, GeoUnit cUnit,
            GeoRadiusParam cParam) {
        Jedis tJedis = RedisPool.getJedis();
        List<GeoRadiusResponse> tGeoradiusByMember = tJedis.georadiusByMember(cKey, cMember, cRadius, cUnit, cParam);
        tJedis.close();
        return tGeoradiusByMember;
    }
}
